#!/usr/bin/env node

// 批量修复：将所有预约数据标记为占号数据（is_placeholder = true）
// 使用方法（Windows PowerShell）：
//   node app/tools/fix-placeholder-status.mjs            # 预览（dry-run）
//   node app/tools/fix-placeholder-status.mjs --apply     # 实际写库
// 可选参数：
//   --limit 200          仅处理最近更新的 N 条候选
//   --db <path>          指定数据库文件路径

import { existsSync } from 'node:fs'
import path from 'node:path'
import process from 'node:process'
import { PrismaClient } from '@prisma/client'

function parseArgs(argv) {
  const args = { apply: false, limit: 0, db: '' }
  for (let i = 2; i < argv.length; i++) {
    const a = argv[i]
    if (a === '--apply') {
      args.apply = true
    }
    else if (a === '--limit') {
      const v = Number(argv[i + 1])
      if (Number.isFinite(v) && v > 0) {
        args.limit = Math.floor(v)
        i++
      }
    }
    else if (a === '--db') {
      const v = argv[i + 1]
      if (v) {
        args.db = v
        i++
      }
    }
  }
  return args
}

async function main() {
  const args = parseArgs(process.argv)
  // 选择数据库：优先 --db；否则自动探测 userData 路径；最后回退到仓库内开发库
  const candidates = []
  if (args.db) {
    candidates.push(args.db)
  }
  const appdata = process.env.APPDATA || ''
  if (process.platform === 'win32' && appdata) {
    candidates.push(path.join(appdata, 'AutoTools', 'data', 'app.db'))
    candidates.push(path.join(appdata, 'auto-tools', 'data', 'app.db'))
  }
  // 仓库内开发库（很可能不是当前运行库，仅作为兜底）
  candidates.push(path.resolve(process.cwd(), 'app', 'prisma', 'data', 'app.db'))

  let picked = ''
  for (const p of candidates) {
    try {
      if (p && existsSync(p)) {
        picked = p
        break
      }
    }
    catch {}
  }
  if (!picked) {
    console.error('[ERROR] 未找到数据库文件。可使用 --db 指定绝对路径，如 C:/Users/Administrator/AppData/Roaming/AutoTools/data/app.db')
    process.exit(2)
  }
  const dbUrl = `file:${picked.replace(/\\/g, '/')}`
  process.env.DATABASE_URL = dbUrl

  const prisma = new PrismaClient({ datasources: { db: { url: dbUrl } } })
  const mode = args.apply ? 'apply' : 'dry-run'
  console.log(`[INFO] 修复占号数据脚本启动 | 模式=${mode} | limit=${args.limit || 'ALL'}`)
  console.log(`[INFO] 使用数据库: ${picked}`)

  try {
    // 1) 查找所有 is_placeholder = false 的记录
    const take = args.limit && args.limit > 0 ? args.limit : undefined
    const candidates = await prisma.appointment_management.findMany({
      where: {
        is_placeholder: false,
      },
      select: {
        id: true,
        sequence_number: true,
        full_name: true,
        appointment_status: true,
        is_placeholder: true,
        created_at: true,
      },
      orderBy: { created_at: 'desc' },
      take,
    })

    if (candidates.length === 0) {
      console.log('[INFO] 未发现需要修复的记录（所有记录都已经是占号数据）。')
      return
    }

    console.log(`[INFO] 发现 ${candidates.length} 条需要修复的记录（is_placeholder = false）。`)

    // 统计信息
    const statusCounts = {}
    for (const r of candidates) {
      const status = r.appointment_status || 'unknown'
      statusCounts[status] = (statusCounts[status] || 0) + 1
    }
    console.log(`[INFO] 状态分布: ${Object.entries(statusCounts).map(([k, v]) => `${k}=${v}`).join(', ')}`)

    let updated = 0
    let skipped = 0

    if (args.apply) {
      console.log(`[INFO] 开始批量更新...`)
      // 使用批量更新以提高性能
      try {
        const result = await prisma.appointment_management.updateMany({
          where: {
            id: { in: candidates.map(c => c.id) },
          },
          data: {
            is_placeholder: true,
          },
        })
        updated = result.count
        console.log(`[INFO] 批量更新完成，共更新 ${updated} 条记录。`)
      }
      catch (e) {
        console.error(`[ERROR] 批量更新失败:`, e?.message || e)
        // 回退到逐条更新
        console.log(`[INFO] 尝试逐条更新...`)
        for (const row of candidates) {
          try {
            await prisma.appointment_management.update({
              where: { id: row.id },
              data: { is_placeholder: true },
            })
            updated++
          }
          catch (err) {
            skipped++
            console.warn(`[WARN] 更新 id=${row.id} (${row.sequence_number}) 失败:`, err?.message || err)
          }
        }
      }
    }
    else {
      // 预览模式：显示前10条示例
      console.log(`[DRYRUN] 预览模式：将更新以下记录（仅显示前10条）:`)
      const preview = candidates.slice(0, 10)
      for (const row of preview) {
        console.log(`  - id=${row.id} sequence=${row.sequence_number} name=${row.full_name} status=${row.appointment_status}`)
      }
      if (candidates.length > 10) {
        console.log(`  ... 还有 ${candidates.length - 10} 条记录`)
      }
      updated = candidates.length
    }

    console.log(`\n[RESULT] 处理完成：${args.apply ? '已更新' : '预计更新'} ${updated} 条，失败/跳过 ${skipped} 条。`)
    if (!args.apply) {
      console.log(`[TIP] 使用 --apply 参数实际执行更新操作。`)
    }
  }
  catch (error) {
    console.error('[ERROR] 执行失败:', error)
    throw error
  }
  finally {
    // 关闭连接
    try {
      await prisma.$disconnect()
    }
    catch {}
  }
}

main().catch((err) => {
  console.error('[FATAL] 脚本异常:', err)
  process.exit(1)
})
